import random

from django.views import View
from rest_framework.generics import GenericAPIView
from rest_framework.mixins import RetrieveModelMixin
from rest_framework.response import Response
from rest_framework.views import APIView

from apps.recruit.models import City, Recruit, Enterprise
from apps.recruit.serializer import CompanySerializer, CitySerializer, JobSerializer


class JobsRecommend(APIView):
    """
    推荐工作
    """

    def get(self, request):
        # 1. 获取 招聘信息 模型类对象
        recruits = Recruit.objects.all()
        # 2. 获取序列化器对象
        ser = JobSerializer(recruits, many=True)
        # 获取ser.data的长度  为下一步做准备
        a = len(ser.data)
        # 3. 添加职位所属公司字段
        for num in range(a):
            # 3.1 获取公司的对应id值
            com_id = ser.data[num]['enterprise']
            # 3.2 根据id获取公司的相关信息
            companies = Enterprise.objects.get(id=com_id)
            # 3.3 获取公司的序列化器对象
            com_ser = CompanySerializer(companies)
            # 3.4 将公司的数据添加到返回数据中
            ser.data[num]['enterprise'] = com_ser.data
        # 4. 由于需求只返回4个数据  所以先删除调大于4的数据
        data = ser.data
        if len(data) > 4:
            for num in range(a - 4):
                del data[num + 4]
        # 5. 返回数据
        return Response(data)


class LatestJobs(APIView):
    """
    最新职位
    """

    def get(self, request):
        # 1. 获取 招聘信息 模型类对象
        all_jobs = Recruit.objects.all().count()
        # 获取最新增加的职位id！！
        recruits = Recruit.objects.filter(id__gte=all_jobs - 4)
        # 2. 获取序列化器对象
        ser = JobSerializer(recruits, many=True)
        # 获取ser.data的长度  为下一步做准备
        a = len(ser.data)
        # 3. 添加职位所属公司字段
        for num in range(a):
            # 3.1 获取公司的对应id值
            com_id = ser.data[num]['enterprise']
            # 3.2 根据id获取公司的相关信息
            companies = Enterprise.objects.get(id=com_id)
            # 3.3 获取公司的序列化器对象
            com_ser = CompanySerializer(companies)
            # 3.4 将公司的数据添加到返回数据中
            ser.data[num]['enterprise'] = com_ser.data
        # 4. 由于需求只返回4个数据  所以先删除调大于4的数据
        data = ser.data
        if len(data) > 4:
            for num in range(a - 4):
                del data[num + 4]
        # 5. 返回数据
        return Response(data)


class HotCompanies(APIView):
    """
    获取热门企业前6名  目前一共四个
    """

    def get(self, request):
        # 1. 获取 企业 模型类对象
        coms = Enterprise.objects.all().order_by('-visits')[0:5]
        # 2. 获取序列化器对象
        ser = CompanySerializer(coms, many=True)
        # 说明： 缺少字段  recruits(公司对应的工作数量) 需要添加

        # 2.1 获取所有的工作数据
        jobs = Recruit.objects.all()
        # 2.2 获取所有的工作对应的公司ID
        job_com_list = []
        for job in jobs:
            job_com_list.append(job.enterprise_id)
        # 2.3 获取所有的公司ID
        all_com_id = []
        for com in coms:
            all_com_id.append(com.id)
        # 2.4 根据把公司ID和工作数量对接起来
        data = ser.data
        for c in all_com_id:
            i = 0

            for j in job_com_list:
                if c == j:
                    i += 1
            for x in range(len(data)):
                if data[x]["id"] == c:
                    list_kong = []
                    for b in range(i):
                        a = random.randint(0, 10)
                        list_kong.append(a)
                    data[x]["recruits"] = list_kong

        # # 2.1 获取所有的公司 id 值
        # coms_id = []
        # for com in coms:
        #     coms_id.append(
        #         com.id
        #     )
        # # 2.2 获取所有的公司数据
        # data = ser.data
        # # 2.3 为字段添加信息
        # i = 0
        # for num in coms_id:
        #     a = Recruit.objects.filter(enterprise_id=num).count()
        #     list_0 = []
        #     list_0.append(a)
        #     data[i]["recruits"] = list_0
        #     i += 1
        # 3. 返回数据
        return Response(ser.data)


class HotCities(APIView):
    """
    获取热门获取热门城市
    """

    def get(self, request):
        # 1. 获取 城市 模型类对象
        cities = City.objects.filter(ishot=1)
        # 2. 获取序列化器对象
        ser = CitySerializer(cities, many=True)
        # 3. 返回数据结果
        return Response(ser.data)


class SearchJobs(APIView):
    """
    职位搜素
    """

    def post(self, request):
        # 1. 获取前端传回的keyword值
        key_word = self.request.data.get('keyword')
        city_name = self.request.data.get('cityname')
        # 2. 获取模型类对象向 和 序列化器
        if city_name is None:
            jobss = Recruit.objects.all()
        else:
            jobss = Recruit.objects.filter(city__contains=city_name)

        ser = JobSerializer(jobss, many=True)
        # 3. 根据不同的keyword返回不同数据
        if key_word == '' or key_word == None:
            data_list = []
            if ser.data is not None:
                for data in ser.data:
                    com = Enterprise.objects.get(id=data["enterprise"])
                    ser_com = CompanySerializer(com)
                    data["enterprise"] = ser_com.data
                    data_list.append(data)
                return Response(data_list)
            else:
                return Response({'errmsg': '没有相关职位信息'})
        else:
            # jobs = Recruit.objects.filter(jobname__contains=key_word, city__contains=city_name)
            jobs = jobss.filter(jobname__contains=key_word)
            # jobs = Recruit.objects.filter(jobname__contains=key_word)
            ser1 = JobSerializer(jobs, many=True)
            data_list = []
            if ser.data is not None:
                for data in ser1.data:
                    if data is not None:
                        com = Enterprise.objects.get(id=data["enterprise"])
                        ser_com = CompanySerializer(com)
                        data["enterprise"] = ser_com.data
                        data_list.append(data)
                return Response(data_list)
            else:
                return Response({'errmsg': '没有相关职位信息'})


class JobDetails(GenericAPIView, RetrieveModelMixin):
    """
    职位的详细信息
    右侧 页面的  个职位待显示
    """
    # 指定查询集  普通用户is_staff字段
    queryset = Recruit.objects.all()
    # 指定序列化器
    serializer_class = JobSerializer

    def retrieve(self, request, *args, **kwargs):
        """
        嵌套返回具体职位信息
        职位信息
            职位对应的这家公司信息
                这家公司所对应的所有职位信息
                    所有职位信息
                        所对应的公司信息
        :param request:
        :param args:
        :param kwargs:
        :return:
        """
        instance = self.get_object()
        serializer = self.get_serializer(instance)
        # 1. 添加公司字段
        com = Enterprise.objects.get(id=serializer.data["enterprise"])
        ser = CompanySerializer(com)
        data = serializer.data
        data["enterprise"] = ser.data
        # print(data["enterprise"]["id"])

        # 2. 添加公司对应的职位  多个!
        # 2.1 获取当前公司的id
        com_id = data["enterprise"]["id"]
        # 2.2 根据公司iD选出所有的职位
        job_model = Recruit.objects.filter(id=com_id)
        job_ser = JobSerializer(job_model, many=True)
        # 2.3 遍历添加到data中
        for i in job_ser.data:
            data["enterprise"]["recruits"] = i

        # 3. 再去职位中添加公司
        com_ii = []
        com_ii.append(data["enterprise"]["recruits"]["id"])
        for x in com_ii:
            # x 是职位的ID
            # 根据职位ID查询公司
            job_1 = Recruit.objects.get(id=x)
            com_1 = Enterprise.objects.get(id=job_1.enterprise_id)
            ser_1 = CompanySerializer(com_1)
            # 在data中添加
            data["enterprise"]["recruits"]["enterprise"] = ser_1.data

        # 4. 在去公司中添加职位数量
        # 1. 获取 企业 模型类对象
        com_2 = Enterprise.objects.get(id=data["enterprise"]["recruits"]["enterprise"]["id"])
        # 说明： 缺少字段  recruits(公司对应的工作数量) 需要添加

        # 2.1 获取所有的工作数据
        jobs = Recruit.objects.filter(enterprise_id=com_2.id)
        i = 0
        for job in jobs:
            # print(job.enterprise_id)
            i += 1
        kong_list = []
        for b in range(i):
            a = random.randint(1, 10)
            kong_list.append(a)
        data["enterprise"]["recruits"]["enterprise"]["recruits"] = kong_list

        return Response(data)

    def get(self, request, pk):
        """
        返回单个职位信息
        :param request:
        :param pk: 职位ID
        :return:
        """
        return self.retrieve(request)

    def put(self, request, pk):
        """"
        浏览量增加
        """
        com = Recruit.objects.get(id=pk)
        com.visits += 1
        com.save()
        return Response({'success': True, 'message': '更新成功'})

    def post(self, request, pk):
        """
        职位收藏
        :param request:
        :param pk:
        :return:
        """
        # 1. 首先判断能否获取用户
        try:
            user = request.user
        except Exception as e:
            return Response({"message": "收藏失败", "success": False})
        # 2. 判断用户是否登录
        if user.is_authenticated:
            # 用户登录成功  收藏信息保存
            rec = Recruit.objects.get(id=pk)
            rec.users.add(user)
            rec.save()
            return Response({'success': True, 'message': '收藏成功'})
        else:
            return Response({'success': False, 'message': '未登录'})


class CompanyDetails(GenericAPIView, RetrieveModelMixin):
    """
    公司详情
    """
    # 指定查询集  普通用户is_staff字段
    queryset = Enterprise.objects.all()
    # 指定序列化器
    serializer_class = CompanySerializer

    def retrieve(self, request, *args, **kwargs):
        """
        嵌套返回具体公司信息
        公司信息
            公司对应的所有职位信息
                每个职位对应的公司信息
                    公司对应的职位(数量)信息
        :param request:
        :param args:
        :param kwargs:
        :return:
        """
        instance = self.get_object()
        serializer = self.get_serializer(instance)
        # 1. 添加职位字段
        # data_all = []
        # for x in range(1):
        k_list = []
        jobs = Recruit.objects.filter(enterprise_id=serializer.data["id"])
        for job in jobs:
            ser = JobSerializer(job)
            data = serializer.data
            k_list.append(ser.data)
            data["recruits"] = k_list
            # print(data["recruits"]["id"])
        for q in range(jobs.count()):
            # 2. 添加 职位 对应的公司
            # 2.1 获取当前职位的id
            com_id = data["recruits"][q]["enterprise"]
            # 2.2 根据职位iD 获取对应的公司ID
            com_model = Enterprise.objects.filter(id=com_id)
            com_ser = CompanySerializer(com_model, many=True)
            # 2.3 遍历添加到data中
            for i in com_ser.data:
                data["recruits"][q]["enterprise"] = com_ser.data

            # 3. 再去公司中添加职位数量
            # 3.1 获取 企业 模型类对象  "recruits"  "enterprise"
            com_2 = Enterprise.objects.get(id=data["recruits"][q]["enterprise"][0]["id"])
            # 说明： 缺少字段  recruits(公司对应的工作数量) 需要添加

            # 3.2 获取所有的工作数据
            jobs = Recruit.objects.filter(enterprise_id=com_2.id)
            i = 0
            for job in jobs:
                print(job.enterprise_id)
                i += 1
            kong_list = []
            for b in range(i):
                a = random.randint(1, 10)
                kong_list.append(a)
            # 3.3 添加
            data["recruits"][q]["enterprise"][0]["recruits"] = kong_list
        # data_all.append(data)

        return Response(data)

    def get(self, request, pk):
        """
        获取公司的详细信息
        :param request:
        :param pk:
        :return:
        """

        return self.retrieve(request)

    def put(self, request, pk):
        """"
        浏览量增加
        """
        com = Enterprise.objects.get(id=pk)
        com.visits += 1
        com.save()
        return Response({'success': True, 'message': '更新成功'})

    def post(self, request, pk):
        """
        公司收藏
        :param request:
        :param pk:
        :return:
        """
        # 1. 首先判断能否获取用户
        try:
            user = request.user
        except Exception as e:
            return Response({"message": "收藏失败", "success": False})
        # 2. 判断用户是否登录
        if user.is_authenticated:
            # 用户登录成功  收藏信息保存
            com = Enterprise.objects.get(id=pk)
            com.users.add(user)
            com.save()
            return Response({'success': True, 'message': '收藏成功'})
        else:
            return Response({'success': False, 'message': '未登录'})


class DelLikeView(APIView):
    def post(self, request, pk):
        # 1. 首先判断能否获取用户
        try:
            user = request.user
        except Exception as e:
            return Response({"message": "收藏失败", "success": False})
        # 2. 判断用户是否登录
        if user.is_authenticated:
            # 用户登录成功  收藏信息保存
            com = Enterprise.objects.get(id=pk)
            com.users.remove(user)
            com.save()
            return Response({'success': True, 'message': '收藏成功'})
        else:
            return Response({'success': False, 'message': '未登录'})
